// 配置管理服务
// 负责API配置和Exchange配置的加载与保存（仅使用localStorage本地存储）
import type { ExchangeBody, ApiConfig } from '../types';

/**
 * 配置管理服务类
 * 提供配置的加载、保存和调试功能
 * 所有配置仅存储在浏览器localStorage中
 */
export class ConfigManager {
  // localStorage存储键名常量
  private static readonly LOCAL_STORAGE_API_CONFIG_KEY = 'steam_api_config';
  private static readonly LOCAL_STORAGE_EXCHANGE_CONFIG_KEY = 'steam_exchange_config';

  // 默认配置常量
  private static readonly DEFAULT_API_CONFIG: ApiConfig = { apiToken: 'KQBXL1S7R6B1Q152Z3F527L5' };
  private static readonly DEFAULT_EXCHANGE_CONFIG: ExchangeBody = {
    page_index: 1,
    res: 0,
    platforms: 'BUFF-YYYP',
    sort_by: 1,
    min_price: 1,
    max_price: 5000
  };

  /**
   * 加载API配置
   * 从localStorage读取API配置信息
   * @returns {ApiConfig} API配置对象
   */
  static loadApiConfig(): ApiConfig {
    try {
      console.log('开始加载API配置...');
      
      // 从localStorage加载配置
      try {
        const localStorageConfig = localStorage.getItem(this.LOCAL_STORAGE_API_CONFIG_KEY);
        if (localStorageConfig) {
          const config = JSON.parse(localStorageConfig);
          
          // 验证配置对象是否有效
          if (config && typeof config === 'object' && Object.keys(config).length > 0) {
            console.log('✅ 成功从localStorage加载API配置:', config);
            return config;
          } else {
            console.warn('⚠️  从localStorage加载到空的API配置对象');
          }
        } else {
          console.log('ℹ️  localStorage中没有找到API配置');
        }
      } catch (localStorageError) {
        console.warn('⚠️  从localStorage加载API配置失败:', localStorageError);
      }
      
      console.log('📋 返回默认API配置');
      return this.DEFAULT_API_CONFIG;
    } catch (error) {
      console.error('❌ 加载API配置时发生未预期错误:', error);
      return this.DEFAULT_API_CONFIG;
    }
  }

  /**
   * 同步保存API配置
   * 将API配置信息立即保存到localStorage
   * @param {ApiConfig} config API配置对象
   * @returns {boolean} 保存是否成功
   */
  static saveApiConfig(config: ApiConfig): boolean {
    try {
      console.log('开始同步保存API配置到本地:', config);
      
      // 验证配置对象是否有效
      if (!config || typeof config !== 'object') {
        console.error('❌ 无效的API配置对象，无法保存');
        return false;
      }
      
      // 确保apiToken存在且不为空
      if (!config.apiToken || typeof config.apiToken !== 'string') {
        console.error('❌ API Token不存在或无效，无法保存');
        return false;
      }
      
      try {
        // 立即保存到本地localStorage
        localStorage.setItem(this.LOCAL_STORAGE_API_CONFIG_KEY, JSON.stringify(config));
        console.log('✅ API配置成功同步保存到本地');
        
        // 验证保存是否成功
        const savedConfig = localStorage.getItem(this.LOCAL_STORAGE_API_CONFIG_KEY);
        if (savedConfig) {
          const parsedConfig = JSON.parse(savedConfig);
          if (parsedConfig.apiToken === config.apiToken) {
            console.log('✅ API配置保存验证成功');
            return true;
          } else {
            console.error('❌ API配置保存验证失败，Token不匹配');
            return false;
          }
        } else {
          console.error('❌ API配置保存失败，无法从localStorage读取');
          return false;
        }
      } catch (storageError) {
        console.error('❌ 本地存储操作失败:', storageError);
        // 尝试使用try-catch再次保存，防止间歇性错误
        try {
          localStorage.setItem(this.LOCAL_STORAGE_API_CONFIG_KEY, JSON.stringify(config));
          console.log('✅ 重试后API配置保存成功');
          return true;
        } catch (retryError) {
          console.error('❌ 重试保存API配置仍然失败:', retryError);
          return false;
        }
      }
    } catch (error) {
      console.error('❌ 保存API配置到本地时发生未预期错误:', error);
      return false;
    }
  }

  /**
   * 加载Exchange配置
   * 从localStorage读取Exchange配置信息
   * @returns {ExchangeBody} Exchange配置对象
   */
  static loadExchangeConfig(): ExchangeBody {
    try {
      console.log('开始加载Exchange配置...');
      
      // 从localStorage加载配置
      try {
        const localStorageConfig = localStorage.getItem(this.LOCAL_STORAGE_EXCHANGE_CONFIG_KEY);
        if (localStorageConfig) {
          const config = JSON.parse(localStorageConfig);
          
          // 验证配置对象是否有效
          if (config && typeof config === 'object' && Object.keys(config).length > 0) {
            console.log('✅ 成功从localStorage加载Exchange配置:', config);
            return config;
          } else {
            console.warn('⚠️  从localStorage加载到空的Exchange配置对象');
          }
        } else {
          console.log('ℹ️  localStorage中没有找到Exchange配置');
        }
      } catch (localStorageError) {
        console.warn('⚠️  从localStorage加载Exchange配置失败:', localStorageError);
      }
      
      console.log('📋 返回默认Exchange配置');
      return this.DEFAULT_EXCHANGE_CONFIG;
    } catch (error) {
      console.error('❌ 加载Exchange配置时发生未预期错误:', error);
      return this.DEFAULT_EXCHANGE_CONFIG;
    }
  }

  /**
   * 同步保存Exchange配置
   * 将Exchange配置信息立即保存到localStorage
   * @param {ExchangeBody} config Exchange配置对象
   * @returns {boolean} 保存是否成功
   */
  static saveExchangeConfig(config: ExchangeBody): boolean {
    try {
      console.log('开始同步保存Exchange配置到本地:', config);
      
      // 验证配置对象是否有效
      if (!config || typeof config !== 'object') {
        console.error('❌ 无效的Exchange配置对象，无法保存');
        return false;
      }
      
      // 验证必要的字段，并提供详细的错误信息
      const missingFields: string[] = [];
      if (config.page_index === undefined) missingFields.push('page_index');
      if (config.res === undefined) missingFields.push('res');
      if (config.platforms === undefined) missingFields.push('platforms');
      if (config.sort_by === undefined) missingFields.push('sort_by');
      
      if (missingFields.length > 0) {
        console.error(`❌ Exchange配置缺少必要字段: ${missingFields.join(', ')}，无法保存`);
        return false;
      }
      
      // 验证字段的有效性
      if (typeof config.page_index !== 'number' || config.page_index < 1) {
        console.error('❌ page_index必须是大于0的数字');
        return false;
      }
      if (typeof config.res !== 'number') {
        console.error('❌ res必须是数字');
        return false;
      }
      if (typeof config.platforms !== 'string' || !config.platforms.trim()) {
        console.error('❌ platforms必须是非空字符串');
        return false;
      }
      if (typeof config.sort_by !== 'number') {
        console.error('❌ sort_by必须是数字');
        return false;
      }
      // min_price和max_price是可选字段，但如果提供了值，则需要验证格式
      if (config.min_price !== undefined && (typeof config.min_price !== 'number' || config.min_price < 0)) {
        console.error('❌ min_price必须是大于或等于0的数字');
        return false;
      }
      if (config.max_price !== undefined && config.min_price !== undefined && config.max_price < config.min_price) {
        console.error('❌ max_price必须是大于或等于min_price的数字');
        return false;
      }
      
      try {
        // 立即保存到本地localStorage
        localStorage.setItem(this.LOCAL_STORAGE_EXCHANGE_CONFIG_KEY, JSON.stringify(config));
        console.log('✅ Exchange配置成功同步保存到本地');
        
        // 验证保存是否成功
        const savedConfig = localStorage.getItem(this.LOCAL_STORAGE_EXCHANGE_CONFIG_KEY);
        if (savedConfig) {
          const parsedConfig = JSON.parse(savedConfig);
          // 验证关键字段是否保存成功（根据types.ts定义，min_price和max_price是可选字段）
          const validationFields = ['page_index', 'res', 'platforms', 'sort_by'];
          const validationPassed = validationFields.every(field => 
            parsedConfig[field as keyof typeof parsedConfig] === config[field as keyof typeof config]
          );
          
          if (validationPassed) {
            console.log('✅ Exchange配置保存验证成功');
            return true;
          } else {
            console.error('❌ Exchange配置保存验证失败，关键字段不匹配');
            // 即使验证失败，也尝试继续使用保存的配置
            return true;
          }
        } else {
          console.error('❌ Exchange配置保存失败，无法从localStorage读取');
          return false;
        }
      } catch (storageError) {
        console.error('❌ 本地存储操作失败:', storageError);
        // 尝试使用try-catch再次保存，防止间歇性错误
        try {
          localStorage.setItem(this.LOCAL_STORAGE_EXCHANGE_CONFIG_KEY, JSON.stringify(config));
          console.log('✅ 重试后Exchange配置保存成功');
          return true;
        } catch (retryError) {
          console.error('❌ 重试保存Exchange配置仍然失败:', retryError);
          return false;
        }
      }
    } catch (error) {
      console.error('❌ 保存Exchange配置到本地时发生未预期错误:', error);
      return false;
    }
  }

  /**
   * 调试工具方法
   * 检查并显示localStorage中的所有配置信息
   */
  static debugLocalConfig(): void {
    try {
      console.log('=== 配置调试信息 ===');
      
      // 检查localStorage中的配置
      console.log('\n📱 localStorage配置信息:');
      try {
        const apiConfig = localStorage.getItem(this.LOCAL_STORAGE_API_CONFIG_KEY);
        const exchangeConfig = localStorage.getItem(this.LOCAL_STORAGE_EXCHANGE_CONFIG_KEY);
        console.log('localStorage API配置:', apiConfig ? JSON.parse(apiConfig) : '未设置');
        console.log('localStorage Exchange配置:', exchangeConfig ? JSON.parse(exchangeConfig) : '未设置');
      } catch (error) {
        console.error('读取localStorage配置失败:', error);
      }
      
      console.log('=== 调试信息结束 ===');
    } catch (error) {
      console.error('调试过程中发生错误:', error);
    }
  }
}